import {MockMethod} from 'vite-plugin-mock';
import Mock from 'mockjs';
import dayjs from 'dayjs'
import { v4 as uuidv4 } from 'uuid';

const mock: MockMethod[] = [

    // 故障列表
    //vue3 使用mockjs 生成故障列表接口 title 'xxxx发生故障故障原因:xxxx' 日期随机日期 今年日期格式(YYYY-MM-DD) 生成20条数据
    {
        url: '/api/fault-list',
        method: 'get',
        response: () => {
            const faultList = [];

            function getRandomDateThisYear() {
                const startOfYear = dayjs().startOf('year');
                const endOfYear = dayjs().endOf('year');
                const randomMillisecond = Math.random() * (endOfYear.valueOf() - startOfYear.valueOf()) + startOfYear.valueOf();
                return dayjs(randomMillisecond).format('YYYY-MM-DD');
            }

            for (let i = 0; i < 20; i++) {
                const faultTitle = `设备${Mock.Random.integer(1, 100)}发生故障，故障原因：${Mock.Random.cword(5, 10)}`;
                const faultDate = getRandomDateThisYear();

                faultList.push({
                    title: faultTitle,
                    date: faultDate,
                });
            }

            return {
                data: faultList,
                message: '成功',
                code: 0
            }
        },
    },

    // 告警信息
    // vue3 使用mockjs 生成告警信息接口 地址 'xxxx' 日期 使用dayjs今年随机日期格式(YYYY-MM-DD HH:mm:ss) 等级 1 2 3随机  描述：随机中文文字描述
    {
        url: '/api/alert-list',
        method: 'get',
        response: () => {
            const faultList = [];

            // 生成今年的随机日期
            function getRandomDateThisYear() {
                const startOfYear = dayjs().startOf('year');
                const endOfYear = dayjs().endOf('year');
                const randomMillisecond = Math.random() * (endOfYear.valueOf() - startOfYear.valueOf()) + startOfYear.valueOf();
                return dayjs(randomMillisecond).format('YYYY-MM-DD HH:mm:ss');
            }

            const alertList = [];

            for (let i = 0; i < 20; i++) {
                const address = `区域${Mock.Random.integer(100, 999)}`;
                const date = getRandomDateThisYear();
                const level = Mock.Random.integer(1, 3);
                const description = Mock.Random.cword(10, 20);
                const user = '李四'+Mock.Random.integer(4, 50);

                alertList.push({
                    address,
                    date,
                    level,
                    description,
                    user,
                });
            }
            return {
                data: alertList,
                message: '成功',
                code: 0
            }
        },
    },

    // 设备定位
    // vue3 使用mockjs 生成摄像头定位接口 name '设备'+index num 随机200-500
    {
        url: '/api/cameraLocation',
        method: 'get',
        response: () => {
            let cameraList = [];
            for (let i = 1; i <= 4; i++) {
                let camera = {
                    name: '设备' + i,
                    value: Mock.Random.integer(200, 500)
                };
                cameraList.push(camera);
            }
            return {
                data: cameraList,
                message: '成功',
                code: 0
            }
        },
    },

    // 设备列表
    // vue3 使用mockjs 生成设备定位接口
    {
        url: '/api/deviceList',
        method: 'get',
        response: () => {
            var deviceList = [{
                name: '设备1',
                id: '1',
                status: 1,
                value: [116.42599051888418, 39.91306312138842]
            }, {
                name: '设备2',
                id: '2',
                status: 0,
                value: [116.41097085075735, 39.930051107522615]
            }, {
                name: '设备3',
                id: '3',
                status: 1,
                value: [116.37518235923983, 39.905425443934355]
            }, {
                name: '设备4',
                id: '4',
                status: 0,
                value: [116.40335322003274, 39.91749036745209]
            }, {
                name: '设备5',
                id: '5',
                status: 1,
                value: [116.43425492957599, 39.91660494131743]
            }]
            return {
                data: deviceList,
                message: '成功',
                code: 0
            }
        },
    },

// 告警预警
// vue3 使用mockjs 生成告警预警接口 场站 随机字符  摄像头 随机字符 事件 随机字符 目标物 随机字符 告警等级 随机1-3 详情
    {
        url: '/api/alerts',
        method: 'get',
        response: () => {
            var deviceList = Mock.mock({
                'alerts|15': [
                    {
                        'station': '@string("upper", 5)', // 场站，5个随机大写字符
                        'camera': '@string("upper", 4)', // 摄像头，4个随机大写字符
                        'event': '@string("lower", 5)', // 事件，5个随机小写字符
                        'object': '@string("lower", 5)', // 目标物，5个随机小写字符
                        'level|1-3': 1, // 告警等级，1-3 的随机整数
                        'details': '@sentence(5)' // 详情，随机生成一个包含五个单词的句子
                    }
                ]
            })
            return {
                data: {
                    list: deviceList.alerts,
                    total: 1000,
                    page: 1,
                    limit: 20
                },
                message: '成功',
                code: 0
            }
        },
    },

    // 告警查询
// vue3 使用mockjs 生成告警查询接口 摄像头IP 操作用户 操作时间 操作内容
    {
        url: '/api/alertLogs',
        method: 'get',
        response: () => {
            function getRandomDateThisYear() {
                const startOfYear = dayjs().startOf('year');
                const endOfYear = dayjs().endOf('year');
                const randomMillisecond = Math.random() * (endOfYear.valueOf() - startOfYear.valueOf()) + startOfYear.valueOf();
                return dayjs(randomMillisecond).format('YYYY-MM-DD HH:mm:ss');
            }

            const alertLogs = Mock.mock({
                'logs|20': [
                    {
                        'cameraIP': '@ip',  // 摄像头IP，生成随机IP
                        'operator|1': ['张三', '李四', '王五', '刘麻子'], // 操作用户，生成随机用户名
                        'operationTime': getRandomDateThisYear, // 操作时间，生成今年随机日期并格式化
                        'operationContent': '摄像头【变倍+】'  // 操作内容，生成随机字符串
                    }
                ]
            });
            return {
                data: {
                    list: alertLogs.logs,
                    total: 1000,
                    page: 1,
                    limit: 20
                },
                message: '成功',
                code: 0
            }
        },
    },

    // 摄像头列表
// vue3 使用mockjs 生成告警查询接口 摄像头IP 操作用户 操作时间 操作内容
    {
        url: '/api/cameraList',
        method: 'get',
        response: () => {
            function getRandomDateThisYear() {
                const startOfYear = dayjs().startOf('year');
                const endOfYear = dayjs().endOf('year');
                const randomMillisecond = Math.random() * (endOfYear.valueOf() - startOfYear.valueOf()) + startOfYear.valueOf();
                return dayjs(randomMillisecond).format('YYYY-MM-DD HH:mm:ss');
            }

            function generateUUID() {
                return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
                    var r = Math.random() * 16 | 0,
                        v = c == 'x' ? r : (r & 0x3 | 0x8);
                    return v.toString(16);
                });
            }

            const alertLogs = Mock.mock({
                'logs|20': [
                    {
                        'id': generateUUID,
                        'organization|1': ['机构1', '机构2', '机构3', '机构4'],  // 摄像头名称
                        'cameraName|1': ['大华1-1', '大华2-1', '大华3-1', '大华4-1'],  // 摄像头名称
                        'user|1': ['admin', 'test', 'user123', 'wanjunshijie'],  // 用户名
                        'time|1': ['5s', '10s', '15s', '30s'],  // 切图时间
                        'cameraIP': '@ip',  // 摄像头IP，生成随机IP
                        'operator|1': ['张三', '李四', '王五', '刘麻子'], // 操作用户，生成随机用户名
                        'operationTime': getRandomDateThisYear, // 操作时间，生成今年随机日期并格式化
                        'status|1': [0, 1],  // 状态
                    }
                ]
            });
            return {
                data: {
                    list: alertLogs.logs,
                    total: 1000,
                    page: 1,
                    limit: 20
                },
                message: '成功',
                code: 0
            }
        },
    },

    // 告警查询导出
// vue3 使用mockjs 生成告警查询接口 摄像头IP 操作用户 操作时间 操作内容
    {
        url: '/api/alertLogsExport',
        method: 'get',
        response: () => {
            function getRandomDateThisYear() {
                const startOfYear = dayjs().startOf('year');
                const endOfYear = dayjs().endOf('year');
                const randomMillisecond = Math.random() * (endOfYear.valueOf() - startOfYear.valueOf()) + startOfYear.valueOf();
                return dayjs(randomMillisecond).format('YYYY-MM-DD HH:mm:ss');
            }

            const alertLogs = Mock.mock({
                'logs|1000': [
                    {
                        'cameraIP': '@ip',  // 摄像头IP，生成随机IP
                        'operator|1': ['张三', '李四', '王五', '刘麻子'], // 操作用户，生成随机用户名
                        'operationTime': getRandomDateThisYear, // 操作时间，生成今年随机日期并格式化
                        'operationContent': '摄像头【变倍+】'  // 操作内容，生成随机字符串
                    }
                ]
            });
            return {
                data: alertLogs.logs,
                message: '成功',
                code: 0
            }
        },
    },

    // 地区告警统计接口
// vue3 mockjs 生成地区告警统计接口 name 地区+下标 value 随机100-300
    {
        url: '/api/alertStatistics',
        method: 'get',
        response: () => {
            const data = [];
// 假设有10个地区
            for (let i = 1; i <= 10; i++) {
                data.push({
                    name: `区域${i}`,
                    value: Mock.Random.integer(100, 300),
                });
            }
            return {
                data: data,
                message: '成功',
                code: 0
            }
        },
    },

    // 白天晚上告警统计
// vue3 mockjs 生成白天晚上告警统计接口 name 日期(yyyy-mm-dd) value 随机1-100
    {
        url: '/api/dayNightAlertStatistics',
        method: 'get',
        response: (options) => {
            function generateAlertStatistics(startDate, endDate) {
                const data = [];
                let start = new Date(startDate);
                let end = new Date(endDate);

                for (let d = start; d <= end; d.setDate(d.getDate() + 1)) {
                    const dateStr = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
                    data.push({
                        name: dateStr,
                        value: Mock.Random.integer(1, 100),
                        value2: Mock.Random.integer(1, 100),
                    });
                }

                return data;
            }

            const startDate = options.query.startDate;
            const endDate = options.query.endDate;
            let data;

            if (startDate && endDate) {
                data = generateAlertStatistics(startDate, endDate);
            } else {
                const end = new Date();
                const start = new Date();
                start.setDate(end.getDate() - 9); // 获取最近10天的数据
                data = generateAlertStatistics(start, end);
            }
            return {
                data: data,
                message: '成功',
                code: 0
            }
        },
    },

    // 识别类型
    // vue3 mockjs 生成识别类型接口 数组20条 序号 自增 方案 随机字符串 类型 随机字符串 用户 中文姓名

    {
        url: '/api/items',
        method: 'get',
        response: (options) => {
            // 自动生成数据规则
            const data = Mock.mock({
                'items|20': [
                    {
                        'id|+1': 1,  // id自增
                        'scheme': '@string("lower", 5)',  // 随机字符串
                        'type': '@string("upper", 3)', // 类型字段，随机大写字母字符串
                        'name': '@cname()'  // 随机中文名字
                    }
                ]
            })

            return {
                data: {
                    list: data.items,
                    total: 1000,
                    page: 1,
                    limit: 20
                },
                message: '成功',
                code: 0
            }
        },
    },

    // 用户列表
    // vue3 mockjs 生成用户列表接口
    // 序号 自增
    // 员工编号 4位数字随机
    // 姓名 中文姓名随机
    // 机构 机构1 机构2 机构3 机构4 随机
    // 账号状态 0或1
    // 角色 管理员 超级管理员 用户
    // 最后登录时间 dayjs 1小时前后时间 年月日时分秒
    // 接受消息 0或1
    // 管理场站 随机字符串

    {
        url: '/api/userList',
        method: 'get',
        response: (options) => {
            // 自动生成数据规则
            const data = Mock.mock({
                'items|20': [
                    {
                        'id|+1': 1, // 序号，自增
                        'employeeNumber|1000-9999': 0, // 员工编号，4位数字随机
                        'name': '@cname()', // 姓名，中文姓名随机
                        'organization|1': ['机构1', '机构2', '机构3', '机构4'], // 机构
                        'accountStatus|1': [0, 1], // 账号状态
                        'role|1': ['管理员', '超级管理员', '用户'], // 角色
                        'lastLoginTime': () => dayjs().subtract(Mock.Random.integer(0, 60), 'minute').format('YYYY-MM-DD HH:mm:ss'),
                        'acceptMessage|1': [0, 1], // 接受消息
                        'manageStation': '@word(5,10)' // 管理场站，随机字符串
                    }
                ]
            })

            return {
                data: {
                    list: data.items,
                    total: 1000,
                    page: 1,
                    limit: 20
                },
                message: '成功',
                code: 0
            }
        },
    },

    // 机构名称
    // vue3 mockjs 机构名称

    {
        url: '/api/generateTreeData',
        method: 'get',
        response: (options) => {

            const generateOrgTreeData = (level = 3) => {
                if (level <= 0) return null;

                return Mock.mock({
                    'data|3-5': [
                        {
                            id: () => uuidv4(),
                            label: level === 3 ? '@ctitle(4, 6)公司' : (level === 2 ? '@ctitle(4, 6)部' : '@ctitle(4, 6)子部'),
                            children: generateOrgTreeData(level - 1)
                        }
                    ]
                }).data;
            };

            const orgTreeData = generateOrgTreeData();
            return {
                data: orgTreeData,
                message: '成功',
                code: 0
            }
        },
    },

    // 系统管理
    // vue3 mockjs 系统管理
    // 模块 [电子地图 告警预警 告警查询 告警设置 数据统计 用户管理 组织机构管理 摄像头管理 故障信息管理 日志管理 系统监控]
    // 所属模块 根目录
    // 排序 1
    // 账号状态 0或1

    {
        url: '/api/systemManagement',
        method: 'get',
        response: (options) => {
            // 自动生成数据规则
            const modules = [
                "电子地图", "告警预警", "告警查询", "告警设置", "数据统计", "用户管理",
                "组织机构管理", "摄像头管理", "故障信息管理", "日志管理", "系统监控"
            ];
            const data = Mock.mock({
                'data|10-20': [
                    {
                        'moduleId|+1': 1,
                        'moduleName|1': modules,
                        'parentModule': '根目录',
                        'order|+1': 1,
                        'accountStatus|1': [0, 1]
                    }
                ]
            });

            return {
                data: {
                    list: data.data,
                    total: 1000,
                    page: 1,
                    limit: 20
                },
                message: '成功',
                code: 0
            }
        },
    },


    // 故障信息管理
    // vue3 mockjs 故障信息管理
    // 故障编号 自增
    // 故障地点 生成随机地址
    // 故障时间 使用dayjs 今日随机时间
    // 故障原因 随机故障原因
    // 提交人 随机提交人中文姓名
    // 故障修复时间 使用dayjs 今日随机时间
    // 状态 0 1 2

    {
        url: '/api/faults',
        method: 'get',
        response: (options) => {
            // 自动生成数据规则
            const faults = Array.from({ length: 100 }).map((_, index) => {
                return {
                    id: index + 1,  // 故障编号，自增
                    location: Mock.Random.city(true),  // 故障地点，生成随机地址
                    faultTime: dayjs().subtract(Mock.Random.natural(0, 23), 'hour').format('YYYY-MM-DD HH:mm:ss'),  // 故障时间，使用 dayjs 生成今日随机时间
                    reason: Mock.Random.ctitle(5, 10),  // 故障原因，随机故障原因
                    submitter: Mock.Random.cname(),  // 提交人，随机提交人中文姓名
                    repairTime: dayjs().subtract(Mock.Random.natural(0, 23), 'hour').format('YYYY-MM-DD HH:mm:ss'),  // 故障修复时间，使用 dayjs 生成今日随机时间
                    status: Mock.Random.natural(0, 2)  // 状态，随机0、1或2
                };
            });

            return {
                data: {
                    list: faults,
                    total: 1000,
                    page: 1,
                    limit: 20
                },
                message: '成功',
                code: 0
            }
        },
    },

    // vue3 mockjs 组织机构管理
    // id 自增
    // 排序
    // 状态 0 1 2
    // 创建时间
    // 备注随机时间
    // 地址
    // 备注
    // 上级机构
    // 电话
    {
        url: '/api/organizations',
        method: 'get',
        response: (options) => {
            // 自动生成数据规则
            const organizations = Array.from({ length: 100 }).map((_, index) => {
                const parentOrgIndex = Mock.Random.natural(0, index);  // 用于生成随机上级机构

                return {
                    id: index + 1,  // id，自增
                    sortOrder: index + 1,  // 排序
                    orgName: `机构${Mock.Random.ctitle(2, 5)}`,  // 机构名称，生成随机的中文标题
                    status: Mock.Random.natural(0, 1),  // 状态，随机0、1或2
                    createTime: dayjs().subtract(Mock.Random.natural(0, 365), 'day').format('YYYY-MM-DD HH:mm:ss'),  // 创建时间，随机日期
                    address: Mock.Random.city(true),  // 地址，生成随机地址
                    remark: Mock.Random.ctitle(3, 10),  // 备注
                    parentOrg: parentOrgIndex > 0 ? `组织${parentOrgIndex}` : '无',  // 上级机构，随机生成或为'无'
                    phone: Mock.Random.string('number', 11)  // 电话，生成随机11位数字
                };
            });

            return {
                data: {
                    list: organizations,
                    total: 1000,
                    page: 1,
                    limit: 20
                },
                message: '成功',
                code: 0
            }
        },
    },
    // 登录
    {
        url: '/api/login',
        method: 'post',
        response: (options) => {
            // options.body 包含了请求的数据
            // 由于请求的数据是 JSON 格式，需要先解析
            const data = options.body
            // 检查用户名和密码
            if (data.username === 'admin' && data.password === '123456') {
                // 如果用户名和密码都是 'admin'，则返回成功的响应
                return {
                    message: '登录成功',
                    code: 1
                }
            } else {
                // 否则，返回错误的响应
                return {
                    message: '账号或密码错误',
                    code: 0
                }
            }
        },
    },
];

export default mock;
